Conventional recommendation systems provide information about matches between users (e.g., shoppers) and items (e.g., books, videos, games) based on user interests, preferences, history, and other factors. For example, if a user has previously acquired (e.g., purchased, rented, borrowed) a set of Items, then a recommendation system may identify similar items and recommend them to the user based on the user's own actions. Conventional recommendation systems may also determine similarities between users or between items and make additional recommendations based on those similarities. For example, if users in a certain demographic and with similar acquisition histories and preferences have acquired a set of items, then a recommendation system may identify items and recommend them to a user based on the actions of other users.
Conventional recommendation systems have employed matrix factorization models to map both users and items to a joint latent factor space of dimensionality f and to model user-item interactions as inner products in the joint factor space. An item may be associated with an item vector whose elements measure the extent to which the item possesses some factors. Similarly, a user may be associated with a user vector whose elements measure the extent of interest the user has in items that are high in corresponding factors. The dot product of the vectors may describe the interaction between the user and item and may be used to determine whether to make a recommendation. More specifically, every user i may be assigned a vector ui in a latent space, and every item j may also be assigned a vector vj in the latent space. The dot product ui·vj represents the score between the user i and the item j. The score represents the strength of the relationship between the user i and the item j.
When computing recommendations for a specific user i using matrix factorization, all the items j in the catalog are typically scored. After all the items j have been scored, the highest scoring items may be selected. This may be represented as: given i, find j=arg max ui·vj. While scoring all the items j and then selecting the highest scoring items provides useful recommendation results, the time required to score all items j and then select the highest scoring items j may consume an unacceptable number of processor cycles and may take an unacceptably long period of time. Additionally, computing all the scores for ui·vj only provides information useful to solve the problem: given i, find j*=arg max ui·vj and provides no information useful for other tasks.
In mathematics, arg max is the argument of the maximum, which is defined as the set of points of the given argument for which the given function attains its maximum value.
      arg    ⁢                  max        x            ⁢              f        ⁡                  (          x          )                      :=      {          x      |              ∀                  y          :                                    f              ⁡                              (                y                )                                      ≤                          f              ⁡                              (                x                )                                                          }  
In other words, arg maxx f(x) is the set of values of x for which f(x) attains its largest value M. For example, if f(x) is 1−|x|, then it attains its maximum value of 1 at x=0 and only there, so arg maxx (1−|x|)={0}.
A recommendation system may want to study and quantify other relationships. For example, a recommendation system may want to find the highest scoring user given a specific item. This may be referred to as the targeting problem and may be described by: given j, find i=arg max ui·vj. A recommendation system may also want to find the highest scoring user given another user. This may be referred to as the matching problem and may be described by: given i, find k*=arg max ui·uk. A recommendation system may also want to find the highest scoring item given another item. This may be referred to as the item-to-item problem and may be described by: given j, find m*=arg max vj·vm. Seen together, the different results sought by a user/item recommendation system may include:
User-to-item: (given i, find j*=arg max ui·vj)
Targeting: (given j, find i*=arg max ui·vj)
Matchmaking: (given i, find k*=arg max ui·uk)
Item to Item: (given j, find m*=arg max vj·vm).
Unfortunately, in conventional systems, computing a score for one result provides no information for computing a score for another result. Thus, the processor cycle consumption and resulting time required may increase even more when multiple solutions are solved for the same item or user. Thus, some conventional systems have attempted to perform faster scoring using, for example, retrieval methodologies that query the latent space that spans from matrix factorization. However, these conventional attempts have failed because the latent space is not metric.